home *** CD-ROM | disk | FTP | other *** search
/ DOpus Plus / DOpus Plus.iso / Tutorial / C Guide / Average_Module1 / DOExchange.c < prev    next >
C/C++ Source or Header  |  1998-10-09  |  36KB  |  908 lines
  1. /*******************************************************************
  2.  
  3.    DOExchange.c
  4.    
  5.    It's a try to do the Exchange work within a dopus popup menu.
  6.    
  7.    Since nothing of the commodities.library is really documented,
  8.    this source may be wrong. If you know more, you may change/add
  9.    what is to do...
  10.    
  11.    SO BE WARNED... - THIS IS A HACK !!
  12.    (even if it seems to be OK)
  13.    
  14.    Initial idea by Jens Weyer. 
  15.    
  16. *********************************************************************/
  17.  
  18. #include "includes/DOExchange.h"
  19.  
  20. /********************************************************************/
  21. // some prototypes
  22.  
  23. ULONG __asm __saveds New_Proc_Startup( register __a0 IPCData *ipc,
  24.                                        register __a1 DOE_Data *dd );
  25.  
  26. void __saveds New_Proc( void );
  27. void CleanUp( DOE_Data *dd, IPCData *ipc );
  28.  
  29. BOOL OpenWin( DOE_Data *dd );
  30. void BorderDraw( DOE_Data *dd, BOOL invers );
  31.  
  32. BOOL InitPopupMenu( DOE_Data *dd );
  33. APTR CreateSubMenu( DOE_Data *dd, ULONG from, ULONG to );
  34. void ClearPopupMenu( DOE_Data *dd );
  35. BOOL DoMenu( DOE_Data *dd );
  36.  
  37. BOOL HandleWin( DOE_Data *dd );
  38. BOOL HandleCX( DOE_Data *dd );
  39. BOOL HandleNotify( DOE_Data *dd );
  40. BOOL HandleIPC( DOE_Data *dd );
  41.  
  42. BOOL SendCxMsg( CX_OBJ *cxobj, ULONG type, struct MsgPort *reply_to );
  43.  
  44. BOOL WriteConfig( DOE_Data *dd );
  45. BOOL ReadConfig( DOE_Data *dd );
  46.  
  47. /********************************************************************/
  48. // it is surely useful to detach here
  49.  
  50. void DOExchange( STRPTR args, struct Screen *screen, IPCData *ipc )
  51. {
  52.      DOE_Data *dd;
  53.      FuncArgs *fargs;
  54.       
  55.      if( !exchange )
  56.        {
  57.           if( (dd = AllocMemH(mempool, sizeof(DOE_Data))) )
  58.             {
  59.                dd->screen  = screen;
  60.                dd->a4      = getreg( REG_A4 );
  61.                dd->module  = (struct Library *) getreg( REG_A6 );
  62.                dd->library = DOpusBase;
  63.           
  64.                IPC_Launch( 0, 
  65.                            &exchange,         // pointer to pointer to the IPC of the new process, for storing...
  66.                            "DOpus Exchange",  // name of the new process
  67.                            (ULONG) New_Proc,  // entrypoint of the new process
  68.                            4096,              // stack to use
  69.                            (ULONG) dd,        // data to pass to the new process
  70.                            DOSBase );         // pointer to dos.library
  71.                          
  72.                if( !exchange )                // if detaching failed...
  73.                  {
  74.                     FreeMemH( dd );
  75.                     return;
  76.                  }
  77.             }
  78.        }
  79.        
  80.      if( args )
  81.        {  
  82.           if( (fargs = ParseArgs(FUNC0_TEMPLATE, args)) )
  83.             {
  84.                ULONG cmd = 0, counter;
  85.                PassData *pd;
  86.                
  87.                for( counter = 0; counter < TEMPLATE_COUNT; counter++ )
  88.                     if( fargs->FA_Arguments[counter] )
  89.                          cmd |= 1 << counter;
  90.                
  91.                if( (pd = AllocVec(sizeof(PassData), MEMF_CLEAR)) )
  92.                  {
  93.                     pd->FrontPen = ARG_TC   ? *(ULONG *) ARG_TC   : NULL;
  94.                     pd->BackPen  = ARG_BGC  ? *(ULONG *) ARG_BGC  : NULL;
  95.                     pd->name     = ARG_NAME ? (STRPTR)   ARG_NAME : NULL;
  96.                     
  97.                     IPC_Command( exchange, 
  98.                                  cmd,
  99.                                  NULL,
  100.                                  NULL,
  101.                                  pd,              // FreeVec the data automatically
  102.                                  REPLY_NO_PORT );
  103.                   }
  104.                                               
  105.                DisposeArgs( fargs );
  106.              }
  107.        }      
  108. }
  109.  
  110. /********************************************************************/
  111.  
  112. ULONG __asm __saveds New_Proc_Startup( register __a0 IPCData *ipc,
  113.                                        register __a1 DOE_Data *dd )
  114. {     
  115.         struct Library *DOpusBase; 
  116.  
  117.         putreg( REG_A4, dd->a4 );
  118.         dd->ipc = ipc;
  119.         DOpusBase = dd->library;
  120.  
  121.         // now follows our initialization
  122.         
  123.         dd->module->lib_OpenCnt++;
  124.         
  125.         // the default button text
  126.         dd->itext.IText = DOpusGetString( locale, MSG_TEXT );
  127.         dd->itext.FrontPen = 1;
  128.         
  129.         ReadConfig( dd );
  130.         
  131.         if( strlen(dd->name) )
  132.              dd->itext.IText = dd->name;
  133.                 
  134.         // install our notify
  135.         if( !(dd->notify_port   = CreateMsgPort()) ||
  136.             !(dd->notify_handle = AddNotifyRequest(DN_OPUS_HIDE | DN_OPUS_SHOW | DN_OPUS_QUIT |
  137.                                                    DN_CLOSE_WORKBENCH | DN_OPEN_WORKBENCH | DN_RESET_WORKBENCH,
  138.                                                    NULL, dd->notify_port)) )
  139.              return FALSE;
  140.                     
  141.         // fill our newbroker structure
  142.         dd->nb.nb_Version = NB_VERSION;
  143.         dd->nb.nb_Name    = DOpusGetString( locale, FUNC0_DESCRIPTION );
  144.         dd->nb.nb_Title   = dd->nb.nb_Name;
  145.         dd->nb.nb_Descr   = DOpusGetString( locale, MSG_CX_DESCR );
  146.         dd->nb.nb_Unique  = NBU_UNIQUE|NBU_NOTIFY;
  147.         dd->nb.nb_Flags   = COF_SHOW_HIDE;
  148.         
  149.         // create the broker              
  150.         if( !(dd->nb.nb_Port = CreateMsgPort()) ||
  151.             !(dd->our_cxobj  = CxBroker(&dd->nb, (LONG *) &dd->signals)) ||
  152.             dd->signals      ||
  153.             !(dd->sender     = CreateMsgPort()) )
  154.              return FALSE; 
  155.                     
  156.         return TRUE; // all was successfully
  157. } 
  158.  
  159. void __saveds New_Proc( void )
  160. {
  161.      DOE_Data *dd;
  162.      IPCData *ipc;
  163.      struct Library *DOpusBase;
  164.            
  165.      if( !(DOpusBase = (struct Library *) FindName(&((struct ExecBase *)*((ULONG *)4))->LibList, "dopus5.library")) )
  166.           return;
  167.      
  168.      ipc = IPC_ProcStartup( (ULONG *) &dd, New_Proc_Startup );
  169.      putreg( REG_A4, dd->a4 );
  170.      
  171.      if( !ipc )
  172.        {
  173.           if( dd )
  174.                CleanUp( dd, dd->ipc );
  175.                       
  176.           return;
  177.        }
  178.           
  179.      // make our broker aktive
  180.      ActivateCxObj( dd->our_cxobj, TRUE );
  181.                  
  182.      // open the window (looks like a dopus button)            
  183.      if( OpenWin(dd) )
  184.        {                 
  185.           while( TRUE )
  186.             {
  187.                dd->signals = Wait( 1 << dd->sender->mp_SigBit            |                 // reply port of our sended messages
  188.                                    1 << dd->nb.nb_Port->mp_SigBit        |
  189.                                    1 << dd->notify_port->mp_SigBit       |                                 
  190.                                    1 << dd->ipc->command_port->mp_SigBit |                 // ipc messages
  191.                                    (dd->win ? 1 << dd->win->UserPort->mp_SigBit : NULL) ); // IDCMP messages
  192.                
  193.                if( dd->signals & 1 << dd->sender->mp_SigBit ) // our message does return
  194.                  {
  195.                     while( (dd->fmsg = (FakeMsg *) GetMsg(dd->sender)) )
  196.                          FreeMemH( dd->fmsg );                // we have only to free the memory
  197.                  }
  198.                  
  199.                dd->stop = FALSE;
  200.                          
  201.                if( dd->signals & 1 << dd->nb.nb_Port->mp_SigBit )
  202.                  {
  203.                     if( HandleCX(dd) )
  204.                          break;
  205.                  } 
  206.                  
  207.                if( dd->signals & 1 << dd->notify_port->mp_SigBit )
  208.                  {
  209.                     if( HandleNotify(dd) )
  210.                          break;                    
  211.                  } 
  212.                  
  213.                if( dd->signals & 1 << dd->ipc->command_port->mp_SigBit )
  214.                  {
  215.                     if( HandleIPC(dd) )
  216.                          break;
  217.                  } 
  218.                
  219.                if( dd->win && (dd->signals & 1 << dd->win->UserPort->mp_SigBit) )
  220.                  {
  221.                     if( HandleWin(dd) )
  222.                          break;
  223.                  }            
  224.             }       
  225.        }
  226.    
  227.      CleanUp( dd, exchange );
  228.      exchange = NULL;       
  229. }
  230.  
  231. void CleanUp( DOE_Data *dd, IPCData *ipc )
  232. {
  233.      if( dd->win )
  234.           CloseWindow( dd->win );
  235.                
  236.      if( dd->notify_port )
  237.        {
  238.           if( dd->notify_handle )
  239.                RemoveNotifyRequest( dd->notify_handle );
  240.                     
  241.           while( !IsMsgPortEmpty( dd->notify_port) )
  242.                ReplyFreeMsg( GetMsg(dd->notify_port) );
  243.                          
  244.           DeleteMsgPort( dd->notify_port );
  245.        }
  246.        
  247.      DeleteCxObjAll( dd->our_cxobj );
  248.      
  249.      if( dd->nb.nb_Port )
  250.        {
  251.           while( !IsMsgPortEmpty(dd->nb.nb_Port) )
  252.                ReplyMsg( GetMsg(dd->nb.nb_Port) );
  253.           
  254.           DeleteMsgPort( dd->nb.nb_Port );
  255.        }
  256.        
  257.      if( dd->sender )
  258.        {
  259.           while( !IsMsgPortEmpty(dd->sender) )
  260.                FreeMemH( GetMsg(dd->sender) );
  261.           
  262.           DeleteMsgPort( dd->sender );
  263.        }
  264.    
  265.      dd->module->lib_OpenCnt--;
  266.      
  267.      FreeMemH( dd );
  268.      
  269.      IPC_Free( ipc );
  270.      
  271. }
  272.  
  273. /********************************************************************/
  274.  
  275. BOOL OpenWin( DOE_Data *dd )
  276. {    
  277.      // lock the screen   
  278.      if( (dd->screen = LockPubScreen(NULL)) )
  279.        {
  280.           if( (dd->win = OpenWindowTags(  NULL,
  281.                                           WA_Left,   dd->ibox.Left,
  282.                                           WA_Top,    dd->ibox.Top,
  283.                                           WA_Height, dd->screen->Font->ta_YSize + 4,
  284.                                           WA_Width,  IntuiTextLength( &dd->itext ) + 5,
  285.                                     
  286.                                           WA_Gadgets, &draggadget,
  287.                                     
  288.                                           WA_Flags,   WFLG_BORDERLESS | WFLG_NEWLOOKMENUS |
  289.                                                       WFLG_SMART_REFRESH | WFLG_RMBTRAP,
  290.                                                 
  291.                                           WA_IDCMP,   IDCMP_MOUSEBUTTONS,
  292.                                                 
  293.                                           WA_AutoAdjust, TRUE,                                  
  294.                                           WA_PubScreen, dd->screen,
  295.                                           WA_ScreenTitle, (STRPTR) ~0,
  296.                                           TAG_DONE)) )
  297.             {  
  298.                // register our window, so it does get messages
  299.                // even it is inactive
  300.                SetWindowID( dd->win, &dd->id, 0x1400, 0 );
  301.               
  302.                BorderDraw( dd, FALSE );          
  303.             }
  304.      
  305.           UnlockPubScreen( NULL, dd->screen );
  306.        }
  307.            
  308.      return (BOOL) dd->win;     
  309. }
  310.  
  311. void BorderDraw( DOE_Data *dd, BOOL invers )
  312. {     
  313.    // flood the port with supplied colour
  314.    SetRast( dd->win->RPort, dd->itext.BackPen );
  315.    
  316.    // draw a border         
  317.    SetAPen( dd->win->RPort, invers ? 2 : 1 );
  318.    Move( dd->win->RPort, 1, dd->win->Height - 1 );
  319.    Draw( dd->win->RPort, dd->win->Width-1, dd->win->Height - 1 );
  320.    Draw( dd->win->RPort, dd->win->Width-1, 1 );
  321.      
  322.    SetAPen( dd->win->RPort, invers ? 1 : 2 );
  323.    Move( dd->win->RPort, 0, dd->win->Height - 1 );
  324.    Draw( dd->win->RPort, 0, 0 );
  325.    Draw( dd->win->RPort, dd->win->Width-1, 0 );  
  326.    
  327.    // set values for the Rastport
  328.    SetRPAttrs( dd->win->RPort, 
  329.                RPTAG_APen, dd->itext.FrontPen,
  330.                RPTAG_BPen, dd->itext.BackPen,
  331.                TAG_DONE );
  332.                  
  333.    // print the button text
  334.    Move( dd->win->RPort, 3, dd->win->RPort->Font->tf_Baseline + 2 );
  335.    Text( dd->win->RPort, dd->itext.IText, strlen(dd->itext.IText) );    
  336. }
  337.  
  338. /********************************************************************/
  339. // popup menu work
  340.  
  341. // do not be worry, most of this things is only needed to allow:
  342. // - unlimited count of entries with their needed submenu
  343. // - easier to do the cleanup
  344.  
  345. BOOL InitPopupMenu( DOE_Data *dd )
  346. {
  347.      dd->entry_count = 0;
  348.      
  349.      // init the lists we need     
  350.      NewList( (struct List *) &dd->popmenu.item_list );
  351.      NewList( (struct List *) &dd->submenus );
  352.      
  353.      // open the popupmenu above our window
  354.      dd->popmenu.flags  = POPUPMF_ABOVE;
  355.      
  356.      // locale pointer, so we must not supply real strings - only ID's
  357.      dd->popmenu.locale = locale;
  358.      
  359.      // since nothing is documented here, I have done what I think:
  360.      // all brokers must be anywhere in a list and if we have one
  361.      // node (our broker), we can access the whole list...
  362.      dd->ptr_node = (struct Node *) dd->our_cxobj;
  363.      
  364.      // the objects does work with interrupts, it may a good idea
  365.      // to protect the access to the list with Disable()
  366.      Disable();
  367.      
  368.      // go to the head of the list
  369.      do
  370.        {
  371.           dd->ptr_node = dd->ptr_node->ln_Pred;
  372.        }
  373.      while( dd->ptr_node->ln_Pred->ln_Pred );    
  374.    
  375.      // now we can create our needed lists - we have here 2 + X (!)
  376.      // first list         - MinList with the names of the objects (needed by DoPopUpMenu)
  377.      // second list        - MinList, each node contain again a MinList (third list)
  378.      //                      this list is only for easy handling for us
  379.      // third (and X) list - MinList for submenu, it does also contain a pointer
  380.      //                      to the cx_object
  381.       
  382.      do
  383.        {
  384.           // this counter is used to give each (main) menu item an ID.
  385.           // since these items have all submenus, you may also give
  386.           // all the same ID (dopus5.library does only pass them through) 
  387.           dd->entry_count++;
  388.                               
  389.           // now it's time to create the menu entry...
  390.           if( (dd->popitem = AllocMemH(mempool, sizeof(PopUpItem))) )
  391.             {                    
  392.                dd->popitem->item_name = dd->ptr_node->ln_Name;
  393.                dd->popitem->id        = dd->entry_count;
  394.                
  395.                // each item has a submenu
  396.                if( (dd->popitem->data  = CreateSubMenu(dd, MSG_ACTIVATE, MSG_REMOVE)) )
  397.                     dd->popitem->flags = POPUPF_SUB;
  398.                               
  399.                // the next block is a kind of sorted adding of our nodes
  400.                // since this are MinList's, it is not possible to use DOpus
  401.                // list functions here...
  402.                
  403.                // at first we need a pointer to the first node
  404.                dd->compare = (PopUpItem *) dd->popmenu.item_list.mlh_Head;
  405.                
  406.                if( IsListEmpty((struct List *) &dd->popmenu.item_list) ||  
  407.                    Stricmp(dd->popitem->item_name, dd->compare->item_name) < 0 ) // or our new name is lower
  408.                  {
  409.                     AddHead( (struct List *) &dd->popmenu.item_list,
  410.                              (struct Node *) dd->popitem );
  411.                  }
  412.                else
  413.                  {
  414.                     // walk through the list until a name is higher than our new name or
  415.                     // the list is no more entries                 
  416.                     while( dd->compare->node.mln_Succ->mln_Succ &&
  417.                            Stricmp(dd->popitem->item_name, ((PopUpItem *) dd->compare->node.mln_Succ)->item_name) > 0 )
  418.                             dd->compare = (PopUpItem *) dd->compare->node.mln_Succ;
  419.                   
  420.                     // insert the new node before (!) the higher name is coming
  421.                     // or even append it, if no higher entry does exist
  422.                     Insert( (struct List *) &dd->popmenu.item_list,
  423.                             (struct Node *) dd->popitem,
  424.                             (struct Node *) dd->compare );                
  425.                  }                  
  426.             } 
  427.        }
  428.      while( (dd->ptr_node = dd->ptr_node->ln_Succ)->ln_Succ ); 
  429.    
  430.      // we have not all done now, but we must not access longer the object list,
  431.      // so we can allow again all stuff       
  432.      Enable();
  433.      
  434.      // adding a barlabel
  435.      if( (dd->popitem = AllocMemH(mempool, sizeof(PopUpItem))) )
  436.        {
  437.           dd->popitem->item_name = POPUP_BARLABEL;
  438.           dd->popitem->id = 0;
  439.                                  
  440.           AddTail( (struct List *) &dd->popmenu.item_list,
  441.                    (struct Node *) dd->popitem );              
  442.        } 
  443.      
  444.      // adding a item to snap the current settings  
  445.      if( (dd->popitem = AllocMemH(mempool, sizeof(PopUpItem))) )
  446.        {
  447.           dd->popitem->item_name = (STRPTR) MSG_SAVE_POS;
  448.           dd->popitem->id        = POPID_SAVE;
  449.           dd->popitem->flags     = POPUPF_LOCALE;
  450.                         
  451.           AddTail( (struct List *) &dd->popmenu.item_list,
  452.                    (struct Node *) dd->popitem );              
  453.        }
  454.      
  455.      // and an item to allow to quit directly
  456.      if( (dd->popitem = AllocMemH(mempool, sizeof(PopUpItem))) )
  457.        {
  458.           dd->popitem->item_name = (STRPTR) MSG_QUIT;
  459.           dd->popitem->id        = POPID_QUIT;
  460.           dd->popitem->flags     = POPUPF_LOCALE;
  461.                         
  462.           AddTail( (struct List *) &dd->popmenu.item_list,
  463.                    (struct Node *) dd->popitem );              
  464.        } 
  465.      
  466.      return TRUE;
  467. }
  468.  
  469. // this routine is already prepared to be copied if you need it :)
  470. // you must change only small things then...
  471.  
  472. APTR CreateSubMenu( DOE_Data *dd, ULONG from, ULONG to )
  473. {
  474.      PopUpItem *popitem;
  475.      
  476.      if( (dd->submenu_node = AllocMemH(mempool, sizeof(SubMenu_Node))) )
  477.        {
  478.           // init the list
  479.           NewList( (struct List *) &dd->submenu_node->submenu );
  480.                
  481.           // getting the items to show
  482.           for( dd->a4 = from; dd->a4 <= to; dd->a4++ )
  483.             {
  484.                // allocate a node 
  485.                if( (popitem = AllocMemH(mempool, sizeof(PopUpItem))) )
  486.                  {
  487.                     // fill the node
  488.                     popitem->item_name = (STRPTR) dd->a4; 
  489.                     popitem->flags     = POPUPF_LOCALE;
  490.                     popitem->id        = dd->a4;
  491.                     popitem->data      = dd->ptr_node; // pointer to the CX_object
  492.                     
  493.                     switch( dd->a4 )
  494.                       {
  495.                          case MSG_ACTIVATE :
  496.                                              popitem->flags |= POPUPF_CHECKIT;
  497.                                              
  498.                                              // now it is again result of hard work and
  499.                                              // may be wrong... :)
  500.                                              // check the current activation state
  501.                                              //if( ((STRPTR) dd->ptr_node)[0x0E] & 1 << 1 )
  502.                                              if( ((CX_OBJ *) dd->ptr_node)->flags & 1 << 1 )
  503.                                                   popitem->flags |= POPUPF_CHECKED;
  504.                                              
  505.                                              break;
  506.                                              
  507.                          case MSG_APPEAR   :
  508.                          case MSG_DISAPPEAR:
  509.                                              // checking if this object has a GUI
  510.                                              //if( !(((STRPTR) dd->ptr_node)[0x0E] & 1 << 2) )
  511.                                              if( !(((CX_OBJ *) dd->ptr_node)->flags & 1 << 2) )
  512.                                                   popitem->flags |= POPUPF_DISABLED;
  513.                       }
  514.                          
  515.                     // add the popitem node to the submenu list
  516.                     AddTail( (struct List *) &dd->submenu_node->submenu,
  517.                              (struct Node *) popitem );
  518.                  }
  519.             }
  520.           // add the submenu list to the second list, so we can free it later all easily  
  521.           AddTail( (struct List *) &dd->submenus,
  522.                    (struct Node *) dd->submenu_node );
  523.           
  524.           return &dd->submenu_node->submenu;
  525.        }
  526.        
  527.      return NULL;     
  528. }
  529.  
  530. // this routines should be clear for everyone...
  531. void ClearPopupMenu( DOE_Data *dd )
  532. {
  533.      while( !IsListEmpty((struct List *) &dd->popmenu.item_list) )
  534.           FreeMemH( RemHead((struct List *) &dd->popmenu.item_list) );
  535.      
  536.      while( !IsListEmpty((struct List *) &dd->submenus) )
  537.        {
  538.           dd->submenu_node = (SubMenu_Node *) RemHead((struct List *) &dd->submenus);
  539.           
  540.           while( !IsListEmpty((struct List *) &dd->submenu_node->submenu) )
  541.                FreeMemH( RemHead((struct List *) &dd->submenu_node->submenu) );
  542.             
  543.           FreeMemH( dd->submenu_node );
  544.        }       
  545. }
  546.  
  547. BOOL DoMenu( DOE_Data *dd )
  548. {
  549.      // preparing the popupmenu
  550.      if( InitPopupMenu(dd) )
  551.        {
  552.           // start the popupmenu
  553.           if( DoPopUpMenu(dd->win, &dd->popmenu, &dd->popitem, MENUDOWN) != -1 )
  554.             {
  555.                // if the previous call does return, dd->popitem contains the user selection
  556.                switch( dd->popitem->id )
  557.                  {
  558.                     case POPID_SAVE : 
  559.                                                 WriteConfig( dd );
  560.                                                 break;
  561.                                           
  562.                     case POPID_QUIT : 
  563.                                                 dd->stop = TRUE;
  564.                                                 break;
  565.                   
  566.                     case MSG_ACTIVATE:     
  567.                     case MSG_APPEAR:     
  568.                     case MSG_DISAPPEAR:
  569.                     case MSG_REMOVE:    // create a fake CxMsg (not documented...)
  570.                                         // and send it to the choosed CxObj
  571.                                                 
  572.                                         SendCxMsg( (CX_OBJ *) dd->popitem->data, // send it to...
  573.                                                    (dd->popitem->id == MSG_ACTIVATE ? (dd->popitem->flags & POPUPF_CHECKED ? CXCMD_ENABLE : CXCMD_DISABLE) : (dd->popitem->id - MSG_ACTIVATE)*2 + 17 ),
  574.                                                    dd->sender ); // use this port to reply to
  575.                                                
  576.                                         break;
  577.                     }
  578.                }   
  579.              // free the menu
  580.              ClearPopupMenu( dd );                 
  581.        }
  582.        
  583.      return dd->stop;      
  584. }
  585.  
  586. /********************************************************************/
  587. // handling routines
  588.  
  589. BOOL HandleWin( DOE_Data *dd )
  590. {        
  591.    while( !dd->stop && (dd->messages = GetMsg(dd->win->UserPort)) )
  592.      {
  593.         // since we are not interested in other messages, we use a simple "if"
  594.         if( ((struct IntuiMessage *) dd->messages)->Class == IDCMP_MOUSEBUTTONS &&
  595.             ((struct IntuiMessage *) dd->messages)->Code == MENUDOWN )
  596.             //&&
  597.             //((ULONG) WhichLayer(&dd->screen->LayerInfo, dd->screen->MouseX, dd->screen->MouseY)) == ((ULONG) dd->win->WLayer) )
  598.           { 
  599.              // since we have no real gadget, the window must be activated
  600.              // else the popup menu may be in some cases not selectable
  601.              ActivateWindow( dd->win );
  602.                                
  603.              // make our window "selected"
  604.              BorderDraw( dd, TRUE );
  605.              
  606.              dd->stop = DoMenu( dd );
  607.              
  608.              // "unselect"           
  609.              BorderDraw( dd, FALSE );
  610.              
  611.              // deactivate our window again (will activate the previous
  612.                  // activated window, if available)
  613.                  
  614.              if( dd->win->NextWindow )
  615.                       ActivateWindow( dd->win->NextWindow );
  616.                  else
  617.                       dd->win->Flags ^= WFLG_WINDOWACTIVE;           
  618.           } 
  619.         ReplyMsg( dd->messages );        
  620.      }     
  621.    
  622.    return dd->stop;
  623. }
  624.  
  625. BOOL HandleCX( DOE_Data *dd )
  626. {  
  627.    while( !dd->stop && (dd->messages = GetMsg(dd->nb.nb_Port)) )
  628.      {
  629.         // on this place we can use some variables for other work...
  630.         dd->a4      = CxMsgType( (CxMsg *) dd->messages );
  631.         dd->signals = CxMsgID((CxMsg *) dd->messages);
  632.         
  633.         // should be so fast as possible...
  634.         ReplyMsg( dd->messages );
  635.                        
  636.         if(  dd->a4 == CXM_COMMAND )
  637.           {                 
  638.              switch( dd->signals )
  639.                {
  640.                   case CXCMD_DISABLE:    // since we are do not handle any
  641.                                          // other things than our window, it
  642.                                          // is a little bit useless to disable/
  643.                                          // enable, but anyway we do it... :)
  644.                                          ActivateCxObj( dd->our_cxobj, FALSE );
  645.                                          break;
  646.                   
  647.                   case CXCMD_ENABLE:    
  648.                                          ActivateCxObj( dd->our_cxobj, TRUE );
  649.                                          break;
  650.                   
  651.                   case CXCMD_APPEAR:     
  652.                                          if( !dd->win )
  653.                                            {
  654.                                               OpenWin( dd );                                                                                           
  655.                                            }
  656.                                          else
  657.                                               WindowToFront( dd->win );
  658.                                          break;
  659.                   
  660.                   case CXCMD_DISAPPEAR:  
  661.                                          if( dd->win )
  662.                                            {
  663.                                               // save our current position temporally
  664.                                               dd->ibox.Left = dd->win->LeftEdge;
  665.                                               dd->ibox.Top  = dd->win->TopEdge;
  666.                                               
  667.                                               CloseWindow( dd->win );
  668.                                               dd->win = NULL;                                             
  669.                                            }
  670.                                          break;
  671.                   
  672.                   case CXCMD_KILL:      
  673.                                          dd->stop = TRUE;
  674.                                          break;
  675.                                          
  676.                                          
  677.                   /* it seems this value needs a special flag in
  678.                      the newbroker structure and so no messages of
  679.                      this ID does arrive here...
  680.                                          
  681.                   case CXCMD_LIST_CHG:
  682.                                          
  683.                                          break;                                       
  684.                   */                
  685.                }            
  686.           }         
  687.      }
  688.    
  689.    return dd->stop;
  690. }
  691.  
  692. BOOL HandleNotify( DOE_Data *dd )
  693. {
  694.      while( !dd->stop && (dd->messages = GetMsg(dd->notify_port)) )
  695.      {
  696.         switch( ((DOpusNotify *) dd->messages)->dn_Type )
  697.           {
  698.              case DN_OPUS_QUIT :
  699.                                  dd->stop = TRUE;
  700.                                  break;
  701.                                  
  702.                                  
  703.              case DN_CLOSE_WORKBENCH:                    
  704.              case DN_OPUS_HIDE : // storing our current window state
  705.                                  dd->flags = dd->win ? TRUE : FALSE;
  706.                                                                   
  707.                                  SendCxMsg( (CX_OBJ *) dd->our_cxobj,
  708.                                             CXCMD_DISAPPEAR,
  709.                                             dd->sender ); 
  710.                                  break;
  711.                                  
  712.              case DN_OPEN_WORKBENCH:
  713.              case DN_RESET_WORKBENCH:
  714.              case DN_OPUS_SHOW :
  715.                                  if( dd->flags )
  716.                                       SendCxMsg( (CX_OBJ *) dd->our_cxobj,
  717.                                                  CXCMD_APPEAR,
  718.                                                  dd->sender ); 
  719.                                  break;             
  720.           } 
  721.         
  722.         ReplyFreeMsg( dd->messages );
  723.      }
  724.      
  725.    return dd->stop;
  726. }
  727.  
  728. BOOL HandleIPC( DOE_Data *dd )
  729. {
  730.    while( !dd->stop && (dd->messages = GetMsg(dd->ipc->command_port)) )
  731.      {
  732.         if( ((IPCMessage *) dd->messages)->command & IPCCMD_QUIT )
  733.           {
  734.              dd->stop = TRUE;
  735.           }
  736.         else        
  737.           {
  738.              if( ((IPCMessage *) dd->messages)->command & IPCCMD_SHOW )
  739.                {
  740.                   SendCxMsg((CX_OBJ *) dd->our_cxobj, CXCMD_APPEAR, dd->sender );                  
  741.                }
  742.                
  743.              if( ((IPCMessage *) dd->messages)->command & IPCCMD_NAME )
  744.                {
  745.                   // make a copy...
  746.                   strncpy( dd->name, ((PassData *) ((IPCMessage *) dd->messages)->data_free)->name, 11 )[11] = 0;
  747.                   
  748.                   // if the supplied name is empty, it does fallback to the buildin name
  749.                   dd->itext.IText = strlen(dd->name) ? dd->name : DOpusGetString( locale, MSG_TEXT );
  750.                }
  751.                     
  752.              if( ((IPCMessage *) dd->messages)->command & IPCCMD_BGC )
  753.                {
  754.                   dd->itext.BackPen = ((PassData *) ((IPCMessage *) dd->messages)->data_free)->BackPen;
  755.                }
  756.                
  757.              if( ((IPCMessage *) dd->messages)->command & IPCCMD_TC )
  758.                {
  759.                   dd->itext.FrontPen = ((PassData *) ((IPCMessage *) dd->messages)->data_free)->FrontPen;
  760.                }
  761.                                               
  762.              if( dd->win )
  763.                {
  764.                   // save our current position temporally
  765.                   dd->ibox.Left = dd->win->LeftEdge;
  766.                   dd->ibox.Top  = dd->win->TopEdge;
  767.                        
  768.                   if( ((IPCMessage *) dd->messages)->command & IPCCMD_NAME )
  769.                     {
  770.                        // changing the name does require closing and reopening
  771.                        // of the window since the window size depends from the
  772.                        // name... (and font)
  773.                        
  774.                        CloseWindow( dd->win );
  775.                        OpenWin( dd );
  776.                     }
  777.                   
  778.                   if( ((IPCMessage *) dd->messages)->command & (IPCCMD_BGC | IPCCMD_TC) )
  779.                     {
  780.                        BorderDraw( dd, FALSE );
  781.                     }
  782.                     
  783.                   if( ((IPCMessage *) dd->messages)->command & IPCCMD_HIDE )
  784.                     {                                     
  785.                        SendCxMsg((CX_OBJ *) dd->our_cxobj, CXCMD_DISAPPEAR, dd->sender );                                                                 
  786.                     }
  787.                }           
  788.           }
  789.           
  790.         IPC_Reply( dd->messages );       
  791.      }
  792.    
  793.    return dd->stop;
  794. }
  795.  
  796. /********************************************************************/
  797.  
  798. BOOL SendCxMsg( CX_OBJ *cxobj, ULONG type, struct MsgPort *reply_to )
  799. {
  800.    FakeMsg *fmsg;
  801.    
  802.    // create a fake CxMsg (not documented..., size is 232 bytes)
  803.    // and send it to the choosed CxObj
  804.    
  805.    if( (fmsg = AllocMemH(mempool, 232)) )
  806.      {
  807.         fmsg->msg.mn_Node.ln_Type = NT_MESSAGE;
  808.         fmsg->msg.mn_Length       = 232;
  809.         fmsg->Code                = CXM_COMMAND;                                                   
  810.         fmsg->msg.mn_ReplyPort    = reply_to;
  811.         fmsg->ID                  = type;    
  812.         
  813.         PutMsg( cxobj->cx_port, (struct Message *) fmsg );
  814.         
  815.         return TRUE;
  816.       }
  817.       
  818.    return FALSE;
  819. }
  820.  
  821. /********************************************************************/
  822. // saving/reading the config
  823. // normally I use for this an own file, but since here is only to
  824. // write some small values... :)
  825.  
  826. // the following include is only needed to use some defines of it
  827. #include <libraries/iffparse.h>
  828.  
  829. // now we are doing some ID's 
  830. // each data block, which should be recognizeable must have an ID
  831. // (=header)
  832.  
  833. #define  DOE_ID           MAKE_ID('D','O','E','X')
  834. #define  LEFT_TOP         MAKE_ID('L','E','T','E')
  835. #define  COLOURS          MAKE_ID('C','O','L','R')
  836. #define  NEW_NAME         MAKE_ID('N','A','M','E')
  837.  
  838.  
  839. BOOL WriteConfig( DOE_Data *dd )
  840. {
  841.      APTR iffhandle;
  842.      ULONG size;
  843.      
  844.      // open our config file for writing     
  845.      if( (iffhandle = IFFOpen(CONFIG_FILE, IFF_WRITE, DOE_ID)) )
  846.        {  
  847.           // here you can see it is possible to write more than one value
  848.           // with one step, they must only follow each other...          
  849.           IFFWriteChunk( iffhandle, &dd->win->LeftEdge, LEFT_TOP, sizeof(WORD) * 2 );
  850.           IFFWriteChunk( iffhandle, &dd->itext.FrontPen, COLOURS, sizeof(UBYTE) * 2 );
  851.           
  852.           if( (size = strlen(dd->name)) )
  853.             {
  854.                // it's a nice idea to write the \0 of the string too,
  855.                // it does save us work on reading the data
  856.                IFFWriteChunk( iffhandle, dd->name, NEW_NAME, size + 1 );
  857.             }
  858.             
  859.           IFFClose( iffhandle );
  860.           return 0;
  861.         };
  862.                  
  863.      return 1;
  864. }
  865.  
  866. // also simple to understand...
  867.  
  868. BOOL ReadConfig( DOE_Data *dd )
  869. {
  870.      APTR iffhandle;
  871.      ULONG nextchunk;
  872.      
  873.      // open the config file for reading     
  874.      if( (iffhandle = IFFOpen(CONFIG_FILE, IFF_READ, DOE_ID)) )
  875.        {
  876.           // IFFNextChunk() does return the next ID (or NULL if there is none)
  877.           // and so we can switch here
  878.           while( (nextchunk = IFFNextChunk(iffhandle, 0)) )
  879.             {
  880.                 switch( nextchunk )
  881.                   {                                                                                                                                
  882.                        case LEFT_TOP: IFFReadChunkBytes(iffhandle, &dd->ibox, sizeof(WORD) * 2 );
  883.                                       break;
  884.                                       
  885.                        case COLOURS : IFFReadChunkBytes(iffhandle, &dd->itext.FrontPen, sizeof(UBYTE) * 2 );
  886.                                       break;
  887.                                       
  888.                        case NEW_NAME: // if a string should be readed, it is needed to use the
  889.                                       // string alone in a chunk or at least to have it at the
  890.                                       // end of a structure - or -
  891.                                       // if you do this not, you must always write the whole
  892.                                       // structure
  893.                                       // if you try to read an alone written string, you
  894.                                       // must always set the size to read to the lenght of
  895.                                       // you string buffer
  896.                                       
  897.                                       IFFReadChunkBytes(iffhandle, dd->name, 16 );
  898.                                       break;  
  899.                   };
  900.             };
  901.           IFFClose( iffhandle );
  902.                
  903.           return 0;
  904.          
  905.        };
  906.      return 1;
  907. }
  908.